package com.yequan.datastructure.base.array;

import com.yequan.exception.IllegalArgumentException;

import java.util.ArrayList;
import java.util.Objects;

/**
 * @author : Administrator
 * @date : 2019/11/4 20:36
 */
public class Array {

    /**
     * 整型数组
     */
    private int[] data;
    /**
     * 数组长度
     */
    private int n;
    /**
     * 当前长度
     */
    private int count;

    /**
     * 默认加载因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 加载因子:扩容时阈值
     */
    private float loadFactor;

    /**
     * 构造一个容量为capacity的数组
     *
     * @param capacity
     */
    public Array(int capacity) {
        this.data = new int[capacity];
        this.n = capacity;
        this.count = 0;
    }

    /**
     * 构造一个容量为capacity,加载因子为loadFactor的数组
     *
     * @param capacity
     * @param loadFactor
     */
    public Array(int capacity, float loadFactor) {
        this(capacity);
        this.loadFactor = loadFactor;
    }

    /**
     * 获取数组中的值
     * 注意事项:
     * 1.index不能小于0
     * 2.index不能超过当前数组的边界
     *
     * @param index
     * @return
     */
    public int find(int index) {
        if (index < 0 || index >= count) {
            throw new IllegalArgumentException("参数不合法: " + index);
        }
        return data[index];
    }

    /**
     * 插入数据
     * 注意事项:
     * 1.数组是否已满
     * 2.index不能小于0
     * 3.index不能大于count
     *
     * @param index
     * @param value
     * @return
     */
    public boolean insert(int index, int value) {

        //校验数组是否已满
        if (count == n) {
            System.out.println("数组已满,无法插入");
            return false;
        }

        //校验插入数据位置是否合法
        if (index < 0 || index > count) {
            System.out.println("插入位置非法");
            return false;
        }

        //搬移数据,方案一:保持原有顺序,效率低,适合有顺序要求的场景
//        for (int i = count; i > index; i--) {
//            data[i] = data[i - 1];
//        }

        //搬移数据:方案二:打乱原有顺序,将最后一个数据放至index位置,效率高,适合无顺序要求的场景
        data[count] = data[index];

        data[index] = value;
        count++;
        return true;
    }

    /**
     * 删除数组数据
     * 注意事项:
     * 1.数组是否为空
     * 2.index不能小于0
     * 3.index不能大于count-1
     *
     * @param index
     * @return
     */
    public boolean delete(int index) {
        //校验数组为空
        if (count == 0) {
            System.out.println("数组为空");
            return false;
        }
        //校验删除数据位置是否合法
        if (index < 0 || index >= count) {
            System.out.println("删除位置非法");
            return false;
        }

        //搬移数据,方案一:保持原有顺序,效率低,适合有顺序要求的场景
//        for (int i = index + 1; i < count; i++) {
//            data[i - 1] = data[i];
//        }

        //搬移数据:方案二:打乱原有顺序,将最后一个数据放至index位置,效率高,适合无顺序要求的场景
        data[index] = data[count - 1];
        count--;
        return true;

    }

    /**
     * 打印数组全部信息
     */
    public void printAll() {
        for (int i = 0; i < count; i++) {
            System.out.println(data[i] + "  ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Array array = new Array(5);

        for (int i = 0; i < 3; i++) {
            array.insert(i, i + 1);
        }
        array.printAll();

        array.insert(0, 8);
        array.printAll();

        array.delete(0);
        array.printAll();
    }

}
